#include <string.h>
#include <stdio.h>
#include "mhscpu.h"

/* Private function prototypes -----------------------------------------------*/
#ifdef __GNUC__
  /* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
     set to 'Yes') calls __io_putchar() */
  #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
  #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /* __GNUC__ */


void NVIC_Configuration(void);
void UART_Configuration(void);
void GPIO_Configuration(void);

void GPIO_ModeSelect(void);
void GPIO_ConfigGPIOSelect(void);
void GPIO_ConfigPinSelect(void);
void GPIO_PrintConfig(void);
void GPIO_GPIOTest(void);
uint8_t GetCmd(void);

GPIO_TypeDef *GPIOx;
GPIO_InitTypeDef GPIO_InitStruct;

int main(void)
{
	uint8_t tmpCmd = 0;
	
	SYSCTRL_APBPeriphClockCmd(SYSCTRL_APBPeriph_UART0 | SYSCTRL_APBPeriph_GPIO,ENABLE);
	SYSCTRL_APBPeriphResetCmd(SYSCTRL_APBPeriph_UART0,ENABLE);
	
	UART_Configuration();
	NVIC_Configuration();
	
	GPIO_InitStruct.GPIO_Remap = GPIO_Remap_1;

	printf("MegaHunt SCPU GPIO Demo V1.0.\r\n");
	
mainmenu:
	printf("\n");
	printf("m: GPIO_ModeSelect\n");
	printf("g: GPIO_ConfigGPIOSelect\n");
	printf("p: GPIO_ConfigPinSelect\n");
	printf("c: GPIO_PrintConfig\n");
	printf("t: GPIO_GPIOTest\n");
	printf("\n");
	while(TRUE)
	{
		tmpCmd = 0;
		tmpCmd = GetCmd();
		if(tmpCmd)
		{
			switch(tmpCmd)
			{
			case 'M':
			case 'm':
				{
					GPIO_ModeSelect();
					break;
				}
			case 'P':
			case 'p':
				{
					GPIO_ConfigPinSelect();
					break;
				}
			case 'G':
			case 'g':
				{
					GPIO_ConfigGPIOSelect();
					break;
				}
			case 'C':
			case 'c':
				{
					GPIO_PrintConfig();
					break;
				}
			case 'T':
			case 't':
				{
					GPIO_GPIOTest();
					break;
				}
			}
			goto mainmenu;
		}
	}
	
}

uint8_t GetCmd(void)
{
	uint8_t tmpCmd = 0;

	if(UART_GetLineStatus(UART0) & UART_LINE_STATUS_RX_RECVD)
		tmpCmd = UART_ReceiveData(UART0);
	return tmpCmd;
}

void GPIO_GPIOTest(void)
{
	uint8_t tmpCmd = 0;
	uint32_t tmpIOOptFlag = 0;

	printf("GPIO Test in\n");
	printf("0 ~ F:set or reset GPIO\n");
	printf("s:set mode in\n");
	printf("r:reset mode in\n");
	printf("Backspace return\n");

	GPIO_Init(GPIOx, &GPIO_InitStruct);

	while(TRUE)
	{
		tmpCmd = 0;
		tmpCmd = GetCmd();
		if(tmpCmd)
		{
			switch(tmpCmd)
			{
			case '0':
				{
					if (tmpIOOptFlag)
					{
						printf("GPIO_Pin_%c Set\n",tmpCmd);
						GPIO_SetBits(GPIOx, GPIO_Pin_0);
					} 
					else
					{
						printf("GPIO_Pin_%c Reset\n",tmpCmd);
						GPIO_ResetBits(GPIOx, GPIO_Pin_0);
					}
				}
				break;
			case '1':
				{
					if (tmpIOOptFlag)
					{
						printf("GPIO_Pin_%c Set\n",tmpCmd);
						GPIO_SetBits(GPIOx, GPIO_Pin_1);
					} 
					else
					{
						printf("GPIO_Pin_%c Reset\n",tmpCmd);
						GPIO_ResetBits(GPIOx, GPIO_Pin_1);
					}
				}
				break;
			case '2':
				{
					if (tmpIOOptFlag)
					{
						printf("GPIO_Pin_%c Set\n",tmpCmd);
						GPIO_SetBits(GPIOx, GPIO_Pin_2);
					} 
					else
					{
						printf("GPIO_Pin_%c Reset\n",tmpCmd);
						GPIO_ResetBits(GPIOx, GPIO_Pin_2);
					}
				}
				break;
			case '3':
				{
					if (tmpIOOptFlag)
					{
						printf("GPIO_Pin_%c Set\n",tmpCmd);
						GPIO_SetBits(GPIOx, GPIO_Pin_3);
					} 
					else
					{
						printf("GPIO_Pin_%c Reset\n",tmpCmd);
						GPIO_ResetBits(GPIOx, GPIO_Pin_3);
					}
				}
				break;
			case '4':
				{
					if (tmpIOOptFlag)
					{
						printf("GPIO_Pin_%c Set\n",tmpCmd);
						GPIO_SetBits(GPIOx, GPIO_Pin_4);
					} 
					else
					{
						printf("GPIO_Pin_%c Reset\n",tmpCmd);
						GPIO_ResetBits(GPIOx, GPIO_Pin_4);
					}
				}
				break;
			case '5':
				{
					if (tmpIOOptFlag)
					{
						printf("GPIO_Pin_%c Set\n",tmpCmd);
						GPIO_SetBits(GPIOx, GPIO_Pin_5);
					} 
					else
					{
						printf("GPIO_Pin_%c Reset\n",tmpCmd);
						GPIO_ResetBits(GPIOx, GPIO_Pin_5);
					}
				}
				break;
			case '6':
				{
					if (tmpIOOptFlag)
					{
						printf("GPIO_Pin_%c Set\n",tmpCmd);
						GPIO_SetBits(GPIOx, GPIO_Pin_6);
					} 
					else
					{
						printf("GPIO_Pin_%c Reset\n",tmpCmd);
						GPIO_ResetBits(GPIOx, GPIO_Pin_6);
					}
				}
				break;
			case '7':
				{
					if (tmpIOOptFlag)
					{
						printf("GPIO_Pin_%c Set\n",tmpCmd);
						GPIO_SetBits(GPIOx, GPIO_Pin_7);
					} 
					else
					{
						printf("GPIO_Pin_%c Reset\n",tmpCmd);
						GPIO_ResetBits(GPIOx, GPIO_Pin_7);
					}
				}
				break;
			case '8':
				{
					if (tmpIOOptFlag)
					{
						printf("GPIO_Pin_%c Set\n",tmpCmd);
						GPIO_SetBits(GPIOx, GPIO_Pin_8);
					} 
					else
					{
						printf("GPIO_Pin_%c Reset\n",tmpCmd);
						GPIO_ResetBits(GPIOx, GPIO_Pin_8);
					}
				}
				break;
			case '9':
				{
					if (tmpIOOptFlag)
					{
						printf("GPIO_Pin_%c Set\n",tmpCmd);
						GPIO_SetBits(GPIOx, GPIO_Pin_9);
					} 
					else
					{
						printf("GPIO_Pin_%c Reset\n",tmpCmd);
						GPIO_ResetBits(GPIOx, GPIO_Pin_9);
					}
				}
				break;
			case 'A':
			case 'a':
				{
					if (tmpIOOptFlag)
					{
						printf("GPIO_Pin_%c Set\n",tmpCmd);
						GPIO_SetBits(GPIOx, GPIO_Pin_10);
					} 
					else
					{
						printf("GPIO_Pin_%c Reset\n",tmpCmd);
						GPIO_ResetBits(GPIOx, GPIO_Pin_10);
					}
				}
				break;
			case 'B':
			case 'b':
				{
					if (tmpIOOptFlag)
					{
						printf("GPIO_Pin_%c Set\n",tmpCmd);
						GPIO_SetBits(GPIOx, GPIO_Pin_11);
					} 
					else
					{
						printf("GPIO_Pin_%c Reset\n",tmpCmd);
						GPIO_ResetBits(GPIOx, GPIO_Pin_11);
					}
				}
				break;
			case 'C':
			case 'c':
				{
					if (tmpIOOptFlag)
					{
						printf("GPIO_Pin_%c Set\n",tmpCmd);
						GPIO_SetBits(GPIOx, GPIO_Pin_12);
					} 
					else
					{
						printf("GPIO_Pin_%c Reset\n",tmpCmd);
						GPIO_ResetBits(GPIOx, GPIO_Pin_12);
					}
				}
				break;
			case 'D':
			case 'd':
				{
					if (tmpIOOptFlag)
					{
						printf("GPIO_Pin_%c Set\n",tmpCmd);
						GPIO_SetBits(GPIOx, GPIO_Pin_13);
					} 
					else
					{
						printf("GPIO_Pin_%c Reset\n",tmpCmd);
						GPIO_ResetBits(GPIOx, GPIO_Pin_13);
					}
				}
				break;
			case 'E':
			case 'e':
				{
					if (tmpIOOptFlag)
					{
						printf("GPIO_Pin_%c Set\n",tmpCmd);
						GPIO_SetBits(GPIOx, GPIO_Pin_14);
					} 
					else
					{
						printf("GPIO_Pin_%c Reset\n",tmpCmd);
						GPIO_ResetBits(GPIOx, GPIO_Pin_14);
					}
				}
				break;
			case 'F':
			case 'f':
				{
					if (tmpIOOptFlag)
					{
						printf("GPIO_Pin_%c Set\n",tmpCmd);
						GPIO_SetBits(GPIOx, GPIO_Pin_15);
					} 
					else
					{
						printf("GPIO_Pin_%c Reset\n",tmpCmd);
						GPIO_ResetBits(GPIOx, GPIO_Pin_15);
					}
				}
				break;
			case 'S':
			case 's':
				{
					printf("set Mode in\n");
					tmpIOOptFlag = 1;
					break;
				}
			case 'R':
			case 'r':
				{
					printf("reset Mode in\n");
					tmpIOOptFlag = 0;
					break;
				}
			case 0x08:
				{
					return;
				}
			}
		}
	}
}

void GPIO_ModeSelect(void)
{
	uint8_t tmpCmd = 0;

	printf("Test Mode Select\n");
	printf("1: GPIO_Mode_IN_FLOATING\n");
	printf("2: GPIO_Mode_IPU\n");
	printf("3: GPIO_Mode_Out_OD\n");
	printf("4: GPIO_Mode_Out_OD_PU\n");
	printf("5: GPIO_Mode_Out_PP\n");
	printf("Backspace return\n");

	while(TRUE)
	{
		tmpCmd = 0;
		tmpCmd = GetCmd();
		if (tmpCmd)
		{
			switch(tmpCmd)
			{
			case '1':
				{
					printf("Mode GPIO_Mode_IN_FLOATING Select\n");
					GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
					break;
				}
			case '2':
				{
					printf("Mode GPIO_Mode_IPU Select\n");
					GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IPU;
					break;
				}
			case '3':
				{
					printf("Mode GPIO_Mode_Out_OD Select\n");
					GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_OD;
					break;
				}
			case '4':
				{
					printf("Mode GPIO_Mode_Out_OD_PU Select\n");
					GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_OD_PU;
					break;
				}
			case '5':
				{
					printf("Mode GPIO_Mode_Out_PP Select\n");
					GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
					break;
				}
			case 0x08:
				{
					return;
				}
			}
		}

	}
}

void GPIO_ConfigPinSelect(void)
{
	uint8_t tmpCmd = 0;
	int32_t i;

	printf("Test Pin Select\n");
	printf("0 ~ F: Select or Clear Pin Select\n");
	printf("C: Clear All\n");
	printf("Backspace return\n");

	while(TRUE)
	{

		tmpCmd = 0;
		tmpCmd = GetCmd();
		if (tmpCmd)
		{
			if (tmpCmd == 0x08)
			{
				return;
			}
			else if ('0' <= tmpCmd && tmpCmd <= '9' )
			{
				tmpCmd -= 0x30; 
			}
			else
			{
				switch(tmpCmd)
				{
				case 'A':
				case 'a':
					tmpCmd = 10;
					break;
				case 'B':
				case 'b':
					tmpCmd = 11;
					break;
				case 'C':
				case 'c':
					tmpCmd = 12;
					break;
				case 'D':
				case 'd':
					tmpCmd = 13;
					break;
				case 'E':
				case 'e':
					tmpCmd = 14;
					break;
				case 'F':
				case 'f':
					tmpCmd = 15;
					break;
				}
			}

			if (GPIO_InitStruct.GPIO_Pin & ((0x01) << tmpCmd))
			{
				GPIO_InitStruct.GPIO_Pin &= ~((0x01) << tmpCmd);
			}
			else
			{
				GPIO_InitStruct.GPIO_Pin |= ((0x01) << tmpCmd);
			}
			printf("Select Pin:\n");
			printf("FEDCBA9876543210\n");
			for (i = 15;i >= 0; i--)
			{
				if (GPIO_InitStruct.GPIO_Pin & ((0x01) << i))
				{
					printf("1");
				}
				else
				{
					printf("0");
				}
			}
			printf("\n");
		}
	}
}


void GPIO_PrintConfig(void)
{
	int32_t i;

	switch(GPIO_InitStruct.GPIO_Mode)
	{
	case GPIO_Mode_IN_FLOATING:
		{
			printf("Select Mode: GPIO_Mode_IN_FLOATING\n");
			break;
		}
	case GPIO_Mode_IPU:
		{
			printf("Select Mode: GPIO_Mode_IPU\n");
			break;
		}
	case GPIO_Mode_Out_OD:
		{
			printf("Select Mode: GPIO_Mode_Out_OD\n");
			break;
		}
	case GPIO_Mode_Out_OD_PU:
		{
			printf("Select Mode: GPIO_Mode_Out_OD_PU\n");
			break;
		}
	case GPIO_Mode_Out_PP:
		{
			printf("Select Mode: GPIO_Mode_Out_PP\n");
			break;
		}
	default:
		{
			printf("Select Mode: Mode Error\n");
		}
	}


	switch((uint32_t)GPIOx)
	{
	case (uint32_t)GPIOA:
		printf("Select GPIO: GPIOA\n");
		break;
	case (uint32_t)GPIOB:
		printf("Select GPIO: GPIOB\n");
		break;
	case (uint32_t)GPIOC:
		printf("Select GPIO: GPIOC\n");
		break;
	case (uint32_t)GPIOD:
		printf("Select GPIO: GPIOD\n");
		break;
	default:
		{
			printf("Select GPIO: GPIO Error\n");
		}
	}

	printf("Select Pin:\n");
	printf("FEDCBA9876543210\n");
	for (i = 15;i >= 0; i--)
	{
		if (GPIO_InitStruct.GPIO_Pin & ((0x01) << i))
		{
			printf("1");
		}
		else
		{
			printf("0");
		}
	}
	printf("\n");
}

void GPIO_ConfigGPIOSelect(void)
{
	uint8_t tmpCmd = 0;

	printf("Test GPIO Select\n");
	printf("1: GPIOA\n");
	printf("2: GPIOB\n");
	printf("3: GPIOC\n");
	printf("4: GPIOD\n");
	printf("Backspace return\n");

	while(TRUE)
	{
		tmpCmd = 0;
		tmpCmd = GetCmd();
		if (tmpCmd)
		{
			switch(tmpCmd)
			{
			case '1':
				{
					printf("GPIOA Select\n");
					GPIOx = GPIOA;
					break;
				}
			case '2':
				{
					printf("GPIOB Select\n");
					GPIOx = GPIOB;
					break;
				}
			case '3':
				{
					printf("GPIOC Select\n");
					GPIOx = GPIOC;
					break;
				}
			case '4':
				{
					printf("GPIOD Select\n");
					GPIOx = GPIOD;
					break;
				}
			case 0x08:
				{
					return;
				}
			}
		}
	}
}


void NVIC_Configuration(void)
{
	NVIC_InitTypeDef NVIC_InitStructure;

	NVIC_SetPriorityGrouping(NVIC_PriorityGroup_3);
	
	NVIC_InitStructure.NVIC_IRQChannel = UART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
	
	NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;
	//NVIC_Init(&NVIC_InitStructure);
}


void UART_Configuration(void)
{
	UART_InitTypeDef UART_InitStructure;
	
	GPIO_PinRemapConfig(GPIOA, GPIO_Pin_0 | GPIO_Pin_1, GPIO_Remap_0);
	
	UART_InitStructure.UART_BaudRate = 115200;
	UART_InitStructure.UART_WordLength = UART_WordLength_8b;
	UART_InitStructure.UART_StopBits = UART_StopBits_1;
	UART_InitStructure.UART_Parity = UART_Parity_No;

	UART_Init(UART0, &UART_InitStructure);
//    UART_Init(UART1, &UART_InitStructure);
}


//Retarget Printf
int SER_PutChar (int ch)
{
	while(!UART_IsTXEmpty(UART0));
	UART_SendData(UART0, (uint8_t) ch);
//    while(!UART_IsTXEmpty(UART1));
//	UART_SendData(UART1, (uint8_t) ch);
	return ch;
}

int fputc(int c, FILE *f)
{
	/* Place your implementation of fputc here */
	/* e.g. write a character to the USART */
	if (c == '\n')  {
		SER_PutChar('\r');
	}
	return (SER_PutChar(c));
}


#ifdef  USE_FULL_ASSERT

/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t* file, uint32_t line)
{ 
	/* User can add his own implementation to report the file name and line number,
	 ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

	/* Infinite loop */
	while (1)
	{
	}
}
#endif






